package com.gxuwz.lhq.list;


import org.junit.Test;

import java.util.ArrayList;
import java.util.List;
import java.util.function.Consumer;
import java.util.stream.Collectors;
import java.util.stream.Stream;

public class ListTest {

    @Test
    public void testIterate(){
        //iterate重载：
        // 返回通过将函数f迭代应用于初始元素种子而生成的无限顺序有序流，
        // 从而产生由种子、f(种子)、f(种子)等组成的流。
        //流的迭代
        Stream<Integer> iterate = Stream.iterate(1, x -> (x * 2) + 1);

        iterate.limit(10).forEach(System.out::println);
        //有限的迭代(迭代条件)
        Stream<Integer> iterate1 = Stream.iterate(1, t -> t < 1000, t -> (t * 2) + 1);
        iterate1.forEach(System.out::println);

    }

    /**
     * Stream 加强
     */
    @Test
    public void testStream(){

        //增加单个参数构造方法，可为null
        long count = Stream.ofNullable(null).count();
        System.out.println(count);

//        增加 takeWhile 和 dropWhile 方法
        List<Integer> collect = Stream.of(1, 2, 3, 3, 2, 1)
                //takeWhile 返回匹配的元素的最长前缀组成
                .takeWhile(n -> n < 3)
                .collect(Collectors.toList());//[1,2]
        List<Integer> collect1 = Stream.of(1, 2, 3, 3, 2, 1)
                //dropWhile，返回不符合匹配条件的剩余元素组成的流
                .dropWhile(n -> n < 3)
                .collect(Collectors.toList());//[3, 3, 2, 1]
        System.out.println(collect1);



    }
    /**
     * 自 Java 9 开始，Jdk 里面为集合（List/ Set/ Map）都添加了 of 和 copyOf 方法，
     * 它们两个都用来创建不可变的集合
     */

    @Test
    public void testListApi(){
        var list= List.of("java","python");
        var copyList=List.copyOf(list);
        //true
        System.out.println(list==copyList);
    }

    /**
     * new 创建的集合，不属于不可变 AbstractImmutableList 类的子类
     * 可以看出 copyOf 方法会先判断来源集合是不是 AbstractImmutableList 类型的，
     * 如果是，就直接返回，如果不是，则调用 of 创建一个新的集合
     * 源码：
     *  static <E> List<E> listCopy(Collection<? extends E> coll) {
     *         if (coll instanceof AbstractImmutableList && coll.getClass() != SubList.class) {
     *             return (List<E>)coll;
     *         } else {
     *             return (List<E>)List.of(coll.toArray());
     *         }
     *     }
     */
    @Test
    public void test2ListApi(){
        var list= new ArrayList<String>();
        var copyList=List.copyOf(list);
        //false
        System.out.println(list==copyList);
    }
    /**
     * 局部变量的类型推断 var
     * var变量的使用必须赋值
     *
     * 在声明隐式类型的lambda表达式的形参时允许使用var
     * 使用var的好处是在使用lambda表达式时给参数加上注解
     * (@Deprecated var x, @Nullable var y) -> x.process(y);
     */
    @Test
    public void test1(){
        var string="hjsdg";
        System.out.println(string.getClass());

        Consumer consumer=(@Deprecated var x)-> System.out.println("x = " + x);


        consumer.accept(12);

    }

}
